home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 4 / Apprentice-Release4.iso / Source Code / Libraries / DCLAP 4j / DClap / DClipboard.cpp < prev    next >
Encoding:
Text File  |  1995-12-17  |  6.3 KB  |  319 lines  |  [TEXT/R*ch]
  1. // UClipboard.cp 
  2.  
  3.  
  4. #include "DClipboard.h"
  5. #include <dgg.h>
  6. #include <DWindow.h>
  7. #include <DPanel.h>
  8. #include <DTaskMaster.h>
  9. #include <DApplication.h>
  10. #include <DViewCentral.h>
  11.  
  12. #ifdef WIN_MAC
  13.     // undef some conflicts b/n Types.h && NlmTypes
  14. #undef Handle
  15. #undef true
  16. #undef false
  17. //#undef Boolean
  18. #include <Scrap.h>
  19. //#define Boolean  Nlm_Boolean
  20. #endif
  21.  
  22.  
  23. DClipboardMgr* gClipboardMgr = NULL;             
  24.  
  25.  
  26. class DInitClipboard {
  27. public:
  28.     DInitClipboard()     { gClipboardMgr = new DClipboardMgr(); }  
  29. };
  30.  
  31. DInitClipboard globalInit; // do init now
  32.  
  33.  
  34.  
  35.  
  36. // class DClipboardMgr
  37.  
  38.  
  39. DClipboardMgr::DClipboardMgr() : DTaskMaster(0)
  40. {
  41.     fClipView = NULL;
  42.     fClipOrphan= NULL;
  43.     fClipWindow = NULL;
  44.     fGotClipType = FALSE;
  45.     fOldScrapStuff= NULL;
  46.     fNewScrapStuff= NULL;
  47.     gClipboardMgr = this;
  48.     fPrefClipType = Str2Idtype("TEXT"); // kPICT, ...
  49.     
  50. #ifdef WIN_MAC
  51.     fOldScrapStuff= MemNew(sizeof(ScrapStuff));
  52.     fNewScrapStuff= MemNew(sizeof(ScrapStuff));
  53. #endif
  54. } 
  55.  
  56.  
  57. void DClipboardMgr::AboutToLoseControl(Boolean convertClipboard)
  58. {
  59.     if (convertClipboard) {
  60.         if (fClipView && !fClipWrittenToSystem) {
  61. #ifdef WIN_MAC
  62.             long err = ZeroScrap();
  63. #endif
  64. #if FIX
  65.              fClipView->WriteToSystemClipboard();  //WriteToDeskScrap
  66. #endif
  67.              fClipWrittenToSystem = TRUE;
  68.             this->LoadSystemClip();
  69.         }
  70.     }
  71. }  
  72.  
  73.  
  74. void DClipboardMgr::LoadSystemClip()
  75. {
  76. #ifdef WIN_MAC
  77.     ScrapStuff* newscrap = InfoScrap();
  78.     MemCpy( fOldScrapStuff, fNewScrapStuff, sizeof(ScrapStuff));
  79.     MemCpy( fNewScrapStuff, newscrap, sizeof(ScrapStuff));
  80. #endif 
  81. }  
  82.  
  83.  
  84.  
  85. void DClipboardMgr::CheckSystemClip()
  86. {
  87.     this->LoadSystemClip();
  88. #ifdef WIN_MAC
  89.     if (((ScrapStuff*)fOldScrapStuff)->scrapCount 
  90.      != ((ScrapStuff*)fNewScrapStuff)->scrapCount) {
  91. #if FIX
  92.         fClipView->FreeFromClipboard();         
  93. #endif
  94.         fClipView = NULL;     
  95.         this->ReadFromSystem();
  96.     }
  97. #endif
  98. }  
  99.  
  100.  
  101.  
  102. long DClipboardMgr::GetDataToPaste(char* data, ulong datalen, long& clipKind)
  103. {
  104.     long length= 0;
  105.     if (fGotClipType) {
  106.         clipKind = fPrefClipType;
  107. #if FIX
  108.         length = fClipView->GivePasteData(data, datalen, clipKind);
  109. #endif
  110.         if (length < 0) ; //Failure((OSErr)length, 0);
  111.         }
  112.     else 
  113.         length = -1;
  114.     return length;
  115. }  
  116.  
  117.  
  118.  
  119.  
  120. void DClipboardMgr::Launch()
  121. {
  122.     // Create the clip window and default view 
  123.     fClipWindow = this->MakeClipboardWindow();
  124.     DView* aview= fClipWindow->FindSubview(kIDClipView);
  125.     if (aview) fClipOrphan = aview;
  126.  
  127.     // Add the clipboard manager as an application behavior
  128.     //gApplication->AddBehavior(this);
  129.  
  130.     this->LoadSystemClip();
  131.     this->ReadFromSystem();
  132. } 
  133.  
  134.  
  135.  
  136. class DClipView : public DNotePanel {
  137. public:
  138.     short fTestFlag;
  139.     DClipView( DWindow* aWindow) :
  140.         DNotePanel( DClipboardMgr::kIDClipView, aWindow, "Clip view"),
  141.         fTestFlag(0)
  142.         {}
  143.     virtual ~DClipView();
  144. };
  145.  
  146. class DClipWindow : public DWindow {
  147. public:
  148.   short  fTestShort;
  149.     DClipWindow() :
  150.      DWindow( DClipboardMgr::kIDClipView+1, NULL, DWindow::document, -5, -5, -50, -20, "Clipboard"),
  151.      fTestShort(0)
  152.      {}
  153.     virtual ~DClipWindow();
  154. };
  155.  
  156. DClipWindow::~DClipWindow()
  157. {
  158.     if (fTestShort) ; // debugger stop point... do we get here !?
  159. }
  160.  
  161. DClipView::~DClipView()
  162. {
  163.     if (fTestFlag) ; // debugger stop point... do we get here !?
  164. }
  165.  
  166. DWindow* DClipboardMgr::MakeClipboardWindow()
  167. {
  168.     DClipWindow* aWindow= new DClipWindow(); 
  169.     if (!fClipOrphan) fClipOrphan= new DClipView( aWindow);
  170.     fClipView = fClipOrphan;
  171.     return aWindow;
  172. } 
  173.  
  174.  
  175. void DClipboardMgr::ReadFromSystem()
  176. {
  177.     DView* aViewForClipboard = this->MakeViewForAlienClipboard();
  178.     this->SetClipView(aViewForClipboard);
  179.     fClipWrittenToSystem = TRUE;     
  180. }  
  181.  
  182.  
  183. DView* DClipboardMgr::MakeViewForAlienClipboard()
  184. {
  185.     DView * aView = NULL;
  186.     //aView= gApplication->MakeViewForAlienClipboard();
  187.     if (!aView) aView = fClipOrphan;
  188.     return aView;
  189. }  
  190.  
  191. void DClipboardMgr::RegainControl(Boolean checkClipboard)
  192. {
  193.     if (checkClipboard) this->CheckSystemClip();
  194. }  
  195.  
  196.  
  197. void DClipboardMgr::SetClipView(DView* clipView)
  198. {
  199.     if (fClipWindow && clipView != fClipView) {
  200.         // get the old clip window scroller if possible
  201.         DView * theSuperView;
  202.         Boolean haveview;
  203.         theSuperView = fClipWindow;
  204.             
  205.             // throw out any views contained in the scroller (or window)
  206.         haveview= false;
  207.         if (theSuperView->fSubordinates) {
  208.             short i, n= theSuperView->fSubordinates->GetSize();
  209.             //for (i=0; i<n; i++) 
  210.             for (i=n-1; i>=0; i--) {
  211.                 DView* subview= (DView*) theSuperView->fSubordinates->At(i);
  212.                 //?? if (fClipWindow->IsVisible()) subview->Close();
  213.                 haveview= (subview == clipView); 
  214.                 Boolean dodelete= (!haveview && subview != fClipOrphan);
  215. #if 1
  216.                 if (subview) {
  217.                     theSuperView->RemoveSubview(subview, false);
  218.                     if (dodelete) {
  219.                  //mswin is failing here at times
  220.                         if (subview->fSubordinates) subview->DeleteSubviews();
  221.                         delete subview; subview= NULL;
  222.                         // RemoveSubview == theSuperView->fSubordinates->AtDelete(i);
  223.                         }
  224.                     }
  225. #else
  226.                 theSuperView->RemoveSubview(subview, dodelete);
  227. #endif
  228.                 }
  229.             }
  230.         
  231.             // pop in the new clipview
  232.         if (clipView) {
  233.             if (!haveview) theSuperView->AddSubordinate(clipView);
  234.             clipView->SetSuperior(theSuperView->GetNlmObject()); 
  235.             clipView->Invalidate();
  236.             clipView->Disable();     
  237.             fClipWrittenToSystem = (clipView == fClipOrphan);
  238.             }
  239.         }
  240.     fClipView = clipView;
  241. } 
  242.  
  243.  
  244. void DClipboardMgr::DoSetupMenus()
  245. {
  246.     gViewCentral->EnableView(DApplication::kShowClipboard);
  247. }  
  248.  
  249.  
  250. void DClipboardMgr::CanPaste(long clipKind)
  251. {
  252. #if FIX
  253.     if (fClipView && !fGotClipType)
  254.         if (fClipView->ContainsClipType(clipKind)) {
  255.             fGotClipType = TRUE;
  256.             fPrefClipType = clipKind;
  257.             }
  258. #endif
  259.     if (fGotClipType)
  260.         gViewCentral->EnableView(DApplication::kPaste);
  261.     else
  262.         gViewCentral->DisableView(DApplication::kPaste);
  263. }  
  264.  
  265.  
  266. Boolean DClipboardMgr::DoMenuTask(long tasknum, DTask* theTask)
  267. {
  268.     switch (tasknum) {
  269.     
  270.         case DApplication::kShowClipboard:
  271. #if 0
  272.             if (fClipWindow == gWindowManager->CurrentWindow())
  273.                 fClipWindow->Close(); //CloseAndFree();     
  274.             else {
  275.                 fClipWindow->Open();
  276.                 fClipWindow->Select();
  277.                 }
  278. #endif
  279.             return true;
  280.             
  281.         default:
  282.             return DTaskMaster::DoMenuTask(tasknum, theTask);
  283.             break;
  284.     }
  285. } 
  286.  
  287.  
  288. Boolean DClipboardMgr::IsMyAction(DTaskMaster* action)
  289. {
  290.     switch (action->Id()) {
  291.         case DApplication::kShowClipboard:
  292.             return DoMenuTask(action->Id(), NULL);
  293.         default:
  294.             return DTaskMaster::IsMyAction(action);
  295.         }
  296. }
  297.  
  298.  
  299. void DClipboardMgr::Close()
  300. {
  301. #ifdef WIN_MAC    
  302.     LoadScrap();
  303. #endif
  304. } 
  305.  
  306.  
  307. short DClipboardMgr::PutToSystem(char* data, ulong datasize, long clipKind)
  308. {
  309.     long err= -1;
  310.  
  311. #ifdef WIN_MAC    
  312.     err = PutScrap( datasize, clipKind, data);
  313. #endif
  314.     return err;
  315. } 
  316.  
  317.  
  318.  
  319.